home *** CD-ROM | disk | FTP | other *** search
/ Aminet 1 (Walnut Creek) / Aminet - June 1993 [Walnut Creek].iso / usenet / sources / volume89 / aplictns / plplot.6 < prev    next >
Internet Message Format  |  1989-04-25  |  65KB
  1. Path: xanth!indri!ames!oliveb!sun!rishathra!page
  2. From: page%rishathra@Sun.COM (Bob Page)
  3. Newsgroups: comp.sources.amiga
  4. Subject: v89i091:  plplot - scientific plotting library, Part06/07
  5. Message-ID: <100943@sun.Eng.Sun.COM>
  6. Date: 25 Apr 89 05:47:05 GMT
  7. Sender: news@sun.Eng.Sun.COM
  8. Lines: 2234
  9. Approved: page@sun.com
  10.  
  11. Submitted-by: amr@dukee.egr.duke.edu (Tony Richardson)
  12. Posting-number: Volume 89, Issue 91
  13. Archive-name: applications/plplot
  14.  
  15. # This is a shell archive.
  16. # Remove anything above and including the cut line.
  17. # Then run the rest of the file through 'sh'.
  18. # Unpacked files will be owned by you and have default permissions.
  19. #----cut here-----cut here-----cut here-----cut here----#
  20. #!/bin/sh
  21. # shar: SHell ARchive
  22. # Run the following text through 'sh' to create:
  23. #    plbeg.c
  24. #    plbin.c
  25. #    plbox.c
  26. #    plbox3.c
  27. #    plccal.c
  28. #    plclr.c
  29. #    plcntr.c
  30. #    plcol.c
  31. #    plcont.c
  32. #    plcvec.c
  33. #    pldeco.c
  34. #    pldtik.c
  35. #    plend.c
  36. #    plenv.c
  37. #    plerrx.c
  38. #    plerry.c
  39. #    plerx1.c
  40. #    plery1.c
  41. #    plfont.c
  42. #    plform.c
  43. #    plgra.c
  44. #    plgrid3.c
  45. #    plgspa.c
  46. #    plhist.c
  47. #    plhrsh.c
  48. #    pljoin.c
  49. #    pllab.c
  50. #    pllclp.c
  51. #    plline.c
  52. #    plmtex.c
  53. #    plnxtv.c
  54. # This is archive 6 of a 7-part kit.
  55. # This archive created: Thu Apr 20 13:47:05 1989
  56. echo "extracting plbeg.c"
  57. sed 's/^X//' << \SHAR_EOF > plbeg.c
  58. X/* Sets up the device "dev" for plotting, dividing the page into "nx" */
  59. X/* by "ny" subpages. */
  60. X
  61. X#include "plplot.h"
  62. X#include <math.h>
  63. X
  64. Xvoid plbeg(dev,nx,ny)      
  65. Xint dev, nx, ny;
  66. X{
  67. X      float scale, def, ht;
  68. X
  69. X      if ((nx <= 0) || (ny <= 0 )) 
  70. X         fatal("Cannot have negative number of subpages in PLSTAR");
  71. X
  72. X      scale = 1.0/sqrt((double)ny);
  73. X      grbeg(dev); 
  74. X      ssub(nx,ny,0);
  75. X
  76. X      /* Set up character, symbol and tick sizes for requested number of */
  77. X      /* subpages */
  78. X
  79. X      gchr(&def,&ht);
  80. X      schr(def*scale,def*scale);
  81. X      gsym(&def,&ht);
  82. X      ssym(def*scale,def*scale);
  83. X      gmaj(&def,&ht);
  84. X      smaj(def*scale,def*scale);
  85. X      gmin(&def,&ht);
  86. X      smin(def*scale,def*scale);
  87. X      slev(1);
  88. X}
  89. SHAR_EOF
  90. echo "extracting plbin.c"
  91. sed 's/^X//' << \SHAR_EOF > plbin.c
  92. X/* Plot a histogram using the arrays x and y to represent data       */
  93. X/* values and frequencies respectively. If centre is false, x values     */
  94. X/* denote the lower edge of the bin, and if centre is true, they        */
  95. X/* they denote the centre of the bin                                */
  96. X
  97. X#include "plplot.h"
  98. X#include <math.h>
  99. X
  100. Xvoid plbin(nbin,x,y,centre)
  101. Xint nbin;
  102. Xint centre;
  103. Xfloat x[], y[];
  104. X{
  105. X
  106. X      int i;
  107. X      float xmin, xmax, vpwxmi, vpwxma, vpwymi, vpwyma;
  108. X
  109. X      int level;
  110. X      glev(&level);
  111. X      if (level<3)fatal("Please set up window before calling PLBIN.");
  112. X
  113. X/*    Check x[i] are in ascending order */
  114. X
  115. X      for(i=0;i<nbin-1;i++)
  116. X        if (x[i] >= x[i+1])
  117. X           fatal("Elements of X(*) must be increasing in PLBIN.");
  118. X
  119. X      gvpw(&vpwxmi,&vpwxma,&vpwymi,&vpwyma);
  120. X      if (!centre) {
  121. X        for(i=0;i<nbin;i++){
  122. X          pljoin(x[i],vpwymi,x[i],y[i]);
  123. X          pljoin(x[i],y[i],x[i+1],y[i]);
  124. X          pljoin(x[i+1],y[i],x[i+1],vpwymi);
  125. X        }
  126. X        if (x[nbin-1] < vpwxma) {
  127. X          pljoin(x[nbin-1],vpwymi,x[nbin-1],y[nbin-1]);
  128. X          pljoin(x[nbin-1],y[nbin-1],vpwxma,y[nbin-1]);
  129. X          pljoin(vpwxma,y[nbin-1],vpwxma,vpwymi);
  130. X        }
  131. X      }
  132. X      else {
  133. X        if (nbin < 2) return;
  134. X        xmin = vpwxmi;
  135. X        xmax = max(0.5*(x[1]+x[2]),vpwxmi);
  136. X        if (xmin < xmax) {
  137. X          pljoin(xmin,vpwymi,xmin,y[1]);
  138. X          pljoin(xmin,y[1],xmax,y[1]);
  139. X          pljoin(xmax,y[1],xmax,vpwymi);
  140. X        }
  141. X        for (i=1;i<nbin-1;i++) {
  142. X          xmin = xmax;
  143. X          xmax = min(0.5*(x[i]+x[i+1]),vpwxma);
  144. X          pljoin(xmin,vpwymi,xmin,y[i]);
  145. X          pljoin(xmin,y[i],xmax,y[i]);
  146. X          pljoin(xmax,y[i],xmax,vpwymi);
  147. X        }
  148. X        xmin = xmax;
  149. X        xmax = vpwxma;
  150. X        if (xmin < xmax) {
  151. X          pljoin(xmin,vpwymi,xmin,y[nbin]);
  152. X          pljoin(xmin,y[nbin],xmax,y[nbin]);
  153. X          pljoin(xmax,y[nbin],xmax,vpwymi);
  154. X        }
  155. X      }
  156. X}
  157. SHAR_EOF
  158. echo "extracting plbox.c"
  159. sed 's/^X//' << \SHAR_EOF > plbox.c
  160. X/* This draws a box around the current viewport. XOPT and YOPT are */
  161. X/* character strings which define the box as follows: */
  162. X
  163. X/* A: Draw axis (X is horizontal line Y=0, Y is vertical line X=0) */
  164. X/* B: Draw bottom (X) or left (Y) edge of frame */
  165. X/* C: Draw top (X) or right (Y) edge of frame */
  166. X/* G: Draws a grid at the major tick interval */
  167. X/* I: Inverts tick marks */
  168. X/* L: Logarithmic axes, major ticks at decades, minor ticks at units */
  169. X/* N: Write numeric label at conventional location */
  170. X/* M: Write numeric label at unconventional location */
  171. X/* T: Draw major tick marks */
  172. X/* S: Draw minor tick marks */
  173. X/* V: (for Y only) Label vertically */
  174. X
  175. X/* xtick, ytick are the major tick intervals required, zero for  */
  176. X/*              automatic selection */
  177. X/* nxsub, nysub are the number of subtick intervals in a major tick */
  178. X/*              interval */
  179. X
  180. X#include "plplot.h"
  181. X#include <stdio.h>
  182. X#include <math.h>
  183. X#include <string.h>
  184. X
  185. X#define betw(c,a,b) ((a<=c && c<=b) || (b<=c && c<=a))
  186. X
  187. Xstatic float xlog[8] = {0.301030, 0.477121, 0.602060, 0.698970,
  188. X                        0.778151, 0.845098, 0.903090, 0.954243};
  189. X
  190. Xvoid plbox(xopt,xtick,nxsub,yopt,ytick,nysub)
  191. Xchar xopt[],yopt[];
  192. Xfloat xtick, ytick;
  193. Xint nxsub, nysub;
  194. X{
  195. X      char string[40];
  196. X      char strtmp[4];
  197. X      int lax,lbx,lcx,lgx,lix,llx,lmx,lnx,lsx,ltx;
  198. X      int lay,lby,lcy,lgy,liy,lly,lmy,lny,lsy,lty,lvy;
  199. X      int xmajor, xminor, ymajor, yminor, xmode, xprec;
  200. X      int ymode, yprec;
  201. X      int i, i1x, i2x, i3x, i4x, i1y, i2y, i3y, i4y, it0;
  202. X      int nxsub1, nysub1;
  203. X      int lxmin, lxmax, lymin, lymax;
  204. X      int pxmin, pxmax, pymin, pymax;
  205. X      int vppxmi, vppxma, vppymi, vppyma;
  206. X      int level;
  207. X      float xpmm, ypmm, defmaj, defmin, htmaj, htmin;
  208. X      float xtick1, ytick1, vpwxmi, vpwxma, vpwymi, vpwyma;
  209. X      float pos, tn, tp, temp;
  210. X
  211. X      glev(&level);
  212. X      if (level<3) fatal("Please set up window before calling PLBOX.");
  213. X
  214. X/* Open  the clip limits to the subpage limits */
  215. X
  216. X      gclp(&lxmin,&lxmax,&lymin,&lymax);
  217. X      gphy(&pxmin,&pxmax,&pymin,&pymax);
  218. X      sclp(pxmin,pxmax,pymin,pymax);
  219. X
  220. X      gvpp(&vppxmi,&vppxma,&vppymi,&vppyma);
  221. X
  222. X/* Tick and subtick sizes in device coords */
  223. X
  224. X      gpixmm(&xpmm,&ypmm);
  225. X      gmaj(&defmaj,&htmaj);
  226. X      gmin(&defmin,&htmin);
  227. X      
  228. X      xmajor=max(round(htmaj*ypmm),1);
  229. X      ymajor=max(round(htmaj*xpmm),1);
  230. X      xminor=max(round(htmin*ypmm),1);
  231. X      yminor=max(round(htmin*xpmm),1);
  232. X
  233. X      xtick1=xtick;
  234. X      nxsub1=nxsub;
  235. X      ytick1=ytick;
  236. X      nysub1=nysub;
  237. X
  238. X      lax=strpos(xopt,'A')!=-1 || strpos(xopt,'a')!=-1;
  239. X      lbx=strpos(xopt,'B')!=-1 || strpos(xopt,'b')!=-1;
  240. X      lcx=strpos(xopt,'C')!=-1 || strpos(xopt,'c')!=-1;
  241. X      lgx=strpos(xopt,'G')!=-1 || strpos(xopt,'g')!=-1;
  242. X      lix=strpos(xopt,'I')!=-1 || strpos(xopt,'i')!=-1;
  243. X      llx=strpos(xopt,'L')!=-1 || strpos(xopt,'l')!=-1;
  244. X      lmx=strpos(xopt,'M')!=-1 || strpos(xopt,'m')!=-1;
  245. X      lnx=strpos(xopt,'N')!=-1 || strpos(xopt,'n')!=-1;
  246. X      lsx=strpos(xopt,'S')!=-1 || strpos(xopt,'s')!=-1;
  247. X      ltx=strpos(xopt,'T')!=-1 || strpos(xopt,'t')!=-1;
  248. X
  249. X      lay=strpos(yopt,'A')!=-1 || strpos(yopt,'a')!=-1;
  250. X      lby=strpos(yopt,'B')!=-1 || strpos(yopt,'b')!=-1;
  251. X      lcy=strpos(yopt,'C')!=-1 || strpos(yopt,'c')!=-1;
  252. X      lgy=strpos(yopt,'G')!=-1 || strpos(yopt,'g')!=-1;
  253. X      liy=strpos(yopt,'I')!=-1 || strpos(yopt,'i')!=-1;
  254. X      lly=strpos(yopt,'L')!=-1 || strpos(yopt,'l')!=-1;
  255. X      lmy=strpos(yopt,'M')!=-1 || strpos(yopt,'m')!=-1;
  256. X      lny=strpos(yopt,'N')!=-1 || strpos(yopt,'n')!=-1;
  257. X      lsy=strpos(yopt,'S')!=-1 || strpos(yopt,'s')!=-1;
  258. X      lty=strpos(yopt,'T')!=-1 || strpos(yopt,'t')!=-1;
  259. X      lvy=strpos(yopt,'V')!=-1 || strpos(yopt,'v')!=-1;
  260. X
  261. X      gvpw(&vpwxmi,&vpwxma,&vpwymi,&vpwyma);
  262. X      lax=lax && (vpwymi*vpwyma<0.0) && !llx;
  263. X      lay=lay && (vpwxmi*vpwxma<0.0) && !lly;
  264. X      if (llx) xtick1=1.0;
  265. X      if (lly) ytick1=1.0;
  266. X      if (ltx || lgx) 
  267. X          pldtik(vpwxmi,vpwxma,&xtick1,&nxsub1,&xmode,&xprec);
  268. X      if (lty || lgy) 
  269. X          pldtik(vpwymi,vpwyma,&ytick1,&nysub1,&ymode,&yprec);
  270. X
  271. X/* Set up tick variables */
  272. X
  273. X      if (lix) {
  274. X        i1x=xminor;
  275. X        i2x=0;
  276. X        i3x=xmajor;
  277. X        i4x=0;
  278. X      }
  279. X      else {
  280. X        i1x=0;
  281. X        i2x=xminor;
  282. X        i3x=0;
  283. X        i4x=xmajor;
  284. X      }
  285. X
  286. X      if (liy) {
  287. X        i1y=yminor;
  288. X        i2y=0;
  289. X        i3y=ymajor;
  290. X        i4y=0;
  291. X      }
  292. X      else {
  293. X        i1y=0;
  294. X        i2y=yminor;
  295. X        i3y=0;
  296. X        i4y=ymajor;
  297. X      }
  298. X
  299. X/* Draw the bottom edge of the box */
  300. X
  301. X      if (lbx) {
  302. X        movphy(vppxmi,vppymi);
  303. X        if (ltx) {
  304. X          tp=xtick1*floor(vpwxmi/xtick1);
  305. Xbedge:
  306. X          tn=tp+xtick1;
  307. X          if (lsx) {
  308. X            if (llx) {
  309. X              for(i=0; i<=7;i++){
  310. X                temp=tp+xlog[i];
  311. X                if (betw(temp,vpwxmi,vpwxma))
  312. X                     plxtik(wcpcx(temp),vppymi,i1x,i2x);
  313. X              }
  314. X            }
  315. X            else {
  316. X              for ( i=1;i<=nxsub1-1;i++) {
  317. X                temp=tp+i*(tn-tp)/nxsub1;
  318. X                if (betw(temp,vpwxmi,vpwxma))
  319. X                     plxtik(wcpcx(temp),vppymi,i1x,i2x);
  320. X              }
  321. X            }
  322. X          }
  323. X          temp=tn;
  324. X          if (betw(temp,vpwxmi,vpwxma)) {
  325. X            plxtik(wcpcx(temp),vppymi,i3x,i4x);
  326. X            tp=tn;
  327. X            goto bedge;
  328. X          }
  329. X        }
  330. X        draphy(vppxma,vppymi);
  331. X      }
  332. X                                           
  333. X/* Draw right-hand edge of box */
  334. X
  335. X      if (lcy) {
  336. X        movphy(vppxma,vppymi);
  337. X        if (lty) {
  338. X          tp=ytick1*floor(vpwymi/ytick1);
  339. Xredge:
  340. X          tn=tp+ytick1;
  341. X          if (lsy) {
  342. X            if (lly) {
  343. X              for(i=0;i<=7;i++) {
  344. X                temp=tp+xlog[i];
  345. X                if (betw(temp,vpwymi,vpwyma))
  346. X                     plytik(vppxma,wcpcy(temp),i2y,i1y);
  347. X              }
  348. X            }
  349. X            else {
  350. X              for(i=1;i<=nysub1-1;i++) {
  351. X                temp=tp+i*(tn-tp)/nysub1;
  352. X                if (betw(temp,vpwymi,vpwyma))
  353. X                     plytik(vppxma,wcpcy(temp),i2y,i1y);
  354. X              }
  355. X            }
  356. X          }
  357. X          temp=tn;
  358. X          if (betw(temp,vpwymi,vpwyma)) {
  359. X            plytik(vppxma,wcpcy(temp),i4y,i3y);
  360. X            tp=tn;
  361. X            goto redge;
  362. X          }
  363. X        }
  364. X        draphy(vppxma,vppyma);
  365. X      }
  366. X
  367. X/* Draw the top edge of the box */
  368. X
  369. X      if (lcx) {
  370. X        movphy(vppxma,vppyma);
  371. X        if (ltx) {
  372. X          tp=xtick1*(floor(vpwxma/xtick1)+1);
  373. Xtedge:
  374. X          tn=tp-xtick1;
  375. X          if (lsx) {
  376. X            if (llx) {
  377. X              for(i=7;i>=0;i--) {
  378. X                temp=tn+xlog[i];
  379. X                if (betw(temp,vpwxmi,vpwxma))
  380. X                     plxtik(wcpcx(temp),vppyma,i2x,i1x);
  381. X              }
  382. X            }
  383. X            else {
  384. X              for(i=nxsub1-1;i>=1;i--) {
  385. X                temp=tn+i*(tp-tn)/nxsub1;
  386. X                if (betw(temp,vpwxmi,vpwxma))
  387. X                     plxtik(wcpcx(temp),vppyma,i2x,i1x);
  388. X              }
  389. X            }
  390. X          }
  391. X          temp=tn;
  392. X          if (betw(temp,vpwxmi,vpwxma)) {
  393. X            plxtik(wcpcx(temp),vppyma,i4x,i3x);
  394. X            tp=tn;
  395. X            goto tedge;
  396. X          }
  397. X        }
  398. X        draphy(vppxmi,vppyma);
  399. X      }
  400. X
  401. X/* Draw left-hand edge of box */
  402. X
  403. X      if (lby) {
  404. X        movphy(vppxmi,vppyma);
  405. X        if (lty) {
  406. X          tp=ytick1*(floor(vpwyma/ytick1)+1);
  407. Xledge:
  408. X          tn=tp-ytick1;
  409. X          if (lsy) {
  410. X            if (lly) {
  411. X              for(i=7;i>=0;i--) {
  412. X                temp=tn+xlog[i];
  413. X                if (betw(temp,vpwymi,vpwyma))
  414. X                     plytik(vppxmi,wcpcy(temp),i1y,i2y);
  415. X              }
  416. X            }
  417. X            else {
  418. X              for(i=nysub1-1;i>=1;i--) {
  419. X                temp=tn+i*(tp-tn)/nysub1;
  420. X                if (betw(temp,vpwymi,vpwyma))
  421. X                     plytik(vppxmi,wcpcy(temp),i1y,i2y);
  422. X              }
  423. X            }
  424. X          }
  425. X          temp=tn;
  426. X          if (betw(temp,vpwymi,vpwyma)) {
  427. X            plytik(vppxmi,wcpcy(temp),i3y,i4y);
  428. X            tp=tn;
  429. X            goto ledge;
  430. X          }
  431. X        }
  432. X        draphy(vppxmi,vppymi);
  433. X      }
  434. X
  435. X/* Draw the horizontal axis */
  436. X
  437. X      if (lax) {
  438. X        it0=wcpcy(0.0);
  439. X        movphy(vppxmi,it0);
  440. X        if (ltx) {
  441. X          tp=xtick1*floor(vpwxmi/xtick1);
  442. Xhaxis:
  443. X          tn=tp+xtick1;
  444. X          if (lsx) {
  445. X            if (llx) {
  446. X              for(i=0;i<=7;i++) {
  447. X                temp=tp+xlog[i];
  448. X                if (betw(temp,vpwxmi,vpwxma))
  449. X                     plxtik(wcpcx(temp),it0,xminor,xminor);
  450. X              }
  451. X            }
  452. X            else {
  453. X              for(i=1;i<=nxsub1-1;i++) {
  454. X                temp=tp+i*(tn-tp)/nxsub1;
  455. X                if (betw(temp,vpwxmi,vpwxma))
  456. X                     plxtik(wcpcx(temp),it0,xminor,xminor);
  457. X              }
  458. X            }
  459. X          }
  460. X          temp=tn;
  461. X          if (betw(temp,vpwxmi,vpwxma)) {
  462. X            plxtik(wcpcx(temp),it0,xmajor,xmajor);
  463. X            tp=tn;
  464. X            goto haxis;
  465. X          }
  466. X        }
  467. X        draphy(vppxma,it0);
  468. X      }
  469. X
  470. X/* Draw the vertical axis */
  471. X
  472. X      if (lay) {
  473. X        it0=wcpcx(0.0);
  474. X        movphy(it0,vppymi);
  475. X        if (lty) {
  476. X          tp=ytick1*floor(vpwymi/ytick1);
  477. Xvaxis:
  478. X          tn=tp+ytick1;
  479. X          if (lsy) {
  480. X            if (lly) {
  481. X              for(i=0;i<=7;i++) {
  482. X                temp=tp+xlog[i];
  483. X                if (betw(temp,vpwymi,vpwyma))
  484. X                   plytik(it0,wcpcy(temp),yminor,yminor);
  485. X              }
  486. X            }
  487. X            else {
  488. X              for(i=1;i<=nysub1-1;i++) {
  489. X                temp=tp+i*(tn-tp)/nysub1;
  490. X                if (betw(temp,vpwymi,vpwyma))
  491. X                     plytik(it0,wcpcy(temp),yminor,yminor);
  492. X              }
  493. X            }
  494. X          }
  495. X          temp=tn;
  496. X          if (betw(temp,vpwymi,vpwyma)) {
  497. X            plytik(it0,wcpcy(temp),ymajor,ymajor);
  498. X            tp=tn;
  499. X            goto vaxis;
  500. X          }
  501. X        }
  502. X        draphy(it0,vppyma);
  503. X      }
  504. X
  505. X/* Draw grid in x direction */
  506. X
  507. X      if (lgx) {
  508. X        tp=xtick1*floor(vpwxmi/xtick1);
  509. Xxgrid:
  510. X          tn=tp+xtick1;
  511. X          if (betw(tn,vpwxmi,vpwxma)) {
  512. X            pljoin(tn,vpwymi,tn,vpwyma);
  513. X            tp=tn;
  514. X            goto xgrid;
  515. X          }
  516. X      }
  517. X
  518. X/* Draw grid in y direction */
  519. X
  520. X      if (lgy) {
  521. X        tp=ytick1*floor(vpwymi/ytick1);
  522. Xygrid:
  523. X          tn=tp+ytick1;
  524. X          if (betw(tn,vpwymi,vpwyma)) {
  525. X            pljoin(vpwxmi,tn,vpwxma,tn);
  526. X            tp=tn;
  527. X            goto ygrid;
  528. X          }
  529. X      }
  530. X
  531. X/* Write horizontal label(s) */
  532. X 
  533. X      if ((lmx || lnx) && ltx) {
  534. X        tp=xtick1*floor(vpwxmi/xtick1);
  535. Xhlabel:
  536. X        tn=tp+xtick1;
  537. X        if (betw(tn,vpwxmi,vpwxma)) {
  538. X          if (!llx)
  539. X            plform(tn,xmode,xprec,string);
  540. X          else {
  541. X            sprintf(strtmp,"%-d",round(tn));
  542. X            strcpy(string,"10\\u");
  543. X            strcat(string,strtmp);
  544. X          }
  545. X          pos=(tn-vpwxmi)/(vpwxma-vpwxmi);
  546. X          if (lnx) plmtex("b",1.5,pos,0.5,string);
  547. X          if (lmx) plmtex("t",1.5,pos,0.5,string);
  548. X          tp=tn;
  549. X          goto hlabel;
  550. X        }
  551. X      }
  552. X
  553. X/* Write vertical label(s) */
  554. X 
  555. X      if ((lmy || lny) && lty) {
  556. X        tp=ytick1*floor(vpwymi/ytick1);
  557. Xvlabel:
  558. X        tn=tp+ytick1             ;
  559. X        if (betw(tn,vpwymi,vpwyma)) {
  560. X          if (!lly) 
  561. X            plform(tn,ymode,yprec,string);
  562. X          else {
  563. X            sprintf(strtmp,"%-d",round(tn));
  564. X            strcpy(string,"10\\u");
  565. X            strcat(string,strtmp);
  566. X          }
  567. X          pos=(tn-vpwymi)/(vpwyma-vpwymi);
  568. X          if (lny) {
  569. X            if (lvy)
  570. X              plmtex("lv",0.5,pos,1.0,string);
  571. X            else
  572. X              plmtex("l",1.5,pos,0.5,string);
  573. X          }
  574. X          if (lmy) {
  575. X            if (lvy) 
  576. X              plmtex("rv",0.5,pos,0.0,string);
  577. X            else
  578. X              plmtex("r",1.5,pos,0.5,string);
  579. X          }
  580. X          tp=tn;
  581. X          goto vlabel;
  582. X        }
  583. X      }
  584. X
  585. X/* Restore the clip limits to viewport edge */
  586. X
  587. X      sclp(lxmin,lxmax,lymin,lymax);
  588. X}
  589. SHAR_EOF
  590. echo "extracting plbox3.c"
  591. sed 's/^X//' << \SHAR_EOF > plbox3.c
  592. X/* Draws axes and axis labels for 3-d plots */
  593. X
  594. X#include "plplot.h"
  595. X
  596. Xvoid plbox3(xopt,xlabel,xtick,nsubx,yopt,ylabel,ytick,nsuby,
  597. X            zopt,zlabel,ztick,nsubz)
  598. Xchar *xopt, *xlabel, *yopt, *ylabel, *zopt, *zlabel;
  599. Xint nsubx, nsuby, nsubz;
  600. Xfloat xtick, ytick, ztick;
  601. X{      
  602. X      float dx,dy,tx,ty,ux,uy;
  603. X      float xmin,xmax,ymin,ymax,zmin,zmax,zscale;
  604. X      float cxx,cxy,cyx,cyy,cyz;
  605. X      int ln;
  606. X
  607. X      int level;
  608. X      glev(&level);
  609. X      if (level < 3) fatal("Please set up window before calling PLBOX3");
  610. X
  611. X      gw3wc(&cxx,&cxy,&cyx,&cyy,&cyz);
  612. X      gdom(&xmin,&xmax,&ymin,&ymax);
  613. X      grange(&zscale,&zmin,&zmax);
  614. X
  615. X      if (cxx >= 0.0 && cxy <= 0.0) {
  616. X        ln=strpos(xopt,'N') != -1 || strpos(xopt,'n') != -1;
  617. X        tx=w3wcx(xmin,ymin,zmin);
  618. X        ty=w3wcy(xmin,ymin,zmin);
  619. X        ux=w3wcx(xmax,ymin,zmin);
  620. X        uy=w3wcy(xmax,ymin,zmin);
  621. X        plxybx(xopt,xlabel,tx,ty,ux,uy,xmin,xmax,xtick,nsubx,0);
  622. X        dx = ux - tx;
  623. X        dy = uy - ty;
  624. X        plzbx(zopt,zlabel,1,dx,dy,ux,uy,
  625. X             w3wcy(xmax,ymin,zmax),zmin,zmax,ztick,nsubz);
  626. X        tx=w3wcx(xmin,ymax,zmin);
  627. X        ty=w3wcy(xmin,ymax,zmin);
  628. X        ux=w3wcx(xmin,ymin,zmin);
  629. X        uy=w3wcy(xmin,ymin,zmin);
  630. X        plxybx(yopt,ylabel,tx,ty,ux,uy,ymax,ymin,ytick,nsuby,ln);
  631. X        dx = ux - tx;
  632. X        dy = uy - ty;
  633. X        plzbx(zopt,zlabel,0,dx,dy,tx,ty,
  634. X             w3wcy(xmin,ymax,zmax),zmin,zmax,ztick,nsubz);
  635. X
  636. X      }
  637. X      else if (cxx <= 0.0 && cxy <= 0.0) {
  638. X        ln=strpos(yopt,'N') != -1 || strpos(yopt,'n') != -1;
  639. X        tx=w3wcx(xmin,ymax,zmin);
  640. X        ty=w3wcy(xmin,ymax,zmin);
  641. X        ux=w3wcx(xmin,ymin,zmin);
  642. X        uy=w3wcy(xmin,ymin,zmin);
  643. X        plxybx(yopt,ylabel,tx,ty,ux,uy,ymax,ymin,ytick,nsuby,0);
  644. X        dx = ux - tx;
  645. X        dy = uy - ty;
  646. X        plzbx(zopt,zlabel,1,dx,dy,ux,uy,
  647. X             w3wcy(xmin,ymin,zmax),zmin,zmax,ztick,nsubz);
  648. X        tx=w3wcx(xmax,ymax,zmin);
  649. X        ty=w3wcy(xmax,ymax,zmin);
  650. X        ux=w3wcx(xmin,ymax,zmin);
  651. X        uy=w3wcy(xmin,ymax,zmin);
  652. X        plxybx(xopt,xlabel,tx,ty,ux,uy,xmax,xmin,xtick,nsubx,ln);
  653. X        dx = ux - tx;
  654. X        dy = uy - ty;
  655. X        plzbx(zopt,zlabel,0,dx,dy,tx,ty,
  656. X             w3wcy(xmax,ymax,zmax),zmin,zmax,ztick,nsubz);
  657. X
  658. X      }
  659. X      else if (cxx <= 0.0 && cxy >= 0.0) {
  660. X        ln=strpos(xopt,'N') != -1 || strpos(xopt,'n') != -1;
  661. X        tx=w3wcx(xmax,ymax,zmin);
  662. X        ty=w3wcy(xmax,ymax,zmin);
  663. X        ux=w3wcx(xmin,ymax,zmin);
  664. X        uy=w3wcy(xmin,ymax,zmin);
  665. X        plxybx(xopt,xlabel,tx,ty,ux,uy,xmax,xmin,xtick,nsubx,0);
  666. X        dx = ux - tx;
  667. X        dy = uy - ty;
  668. X        plzbx(zopt,zlabel,1,dx,dy,ux,uy,
  669. X             w3wcy(xmin,ymax,zmax),zmin,zmax,ztick,nsubz);
  670. X        tx=w3wcx(xmax,ymin,zmin);
  671. X        ty=w3wcy(xmax,ymin,zmin);
  672. X        ux=w3wcx(xmax,ymax,zmin);
  673. X        uy=w3wcy(xmax,ymax,zmin);
  674. X        plxybx(yopt,ylabel,tx,ty,ux,uy,ymin,ymax,ytick,nsuby,ln);
  675. X        dx = ux - tx;
  676. X        dy = uy - ty;
  677. X        plzbx(zopt,zlabel,0,dx,dy,tx,ty,
  678. X             w3wcy(xmax,ymin,zmax),zmin,zmax,ztick,nsubz);
  679. X      }
  680. X      else if (cxx >= 0.0 && cxy >= 0.0) {
  681. X        ln=strpos(yopt,'N') != -1 || strpos(yopt,'n') != -1;
  682. X        tx=w3wcx(xmax,ymin,zmin);
  683. X        ty=w3wcy(xmax,ymin,zmin);
  684. X        ux=w3wcx(xmax,ymax,zmin);
  685. X        uy=w3wcy(xmax,ymax,zmin);
  686. X        plxybx(yopt,ylabel,tx,ty,ux,uy,ymin,ymax,ytick,nsuby,0);
  687. X        dx = ux - tx;
  688. X        dy = uy - ty;
  689. X        plzbx(zopt,zlabel,1,dx,dy,ux,uy,
  690. X             w3wcy(xmax,ymax,zmax),zmin,zmax,ztick,nsubz);
  691. X        tx=w3wcx(xmin,ymin,zmin);
  692. X        ty=w3wcy(xmin,ymin,zmin);
  693. X        ux=w3wcx(xmax,ymin,zmin);
  694. X        uy=w3wcy(xmax,ymin,zmin);
  695. X        plxybx(xopt,xlabel,tx,ty,ux,uy,xmin,xmax,xtick,nsubx,ln);
  696. X        dx = ux - tx;
  697. X        dy = uy - ty;
  698. X        plzbx(zopt,zlabel,0,dx,dy,tx,ty,
  699. X             w3wcy(xmin,ymin,zmax),zmin,zmax,ztick,nsubz);
  700. X
  701. X      }
  702. X}
  703. X
  704. SHAR_EOF
  705. echo "extracting plccal.c"
  706. sed 's/^X//' << \SHAR_EOF > plccal.c
  707. X/* Subroutine to interpolate the position of a contour which is known */
  708. X/* to be next to ix,iy in the direction ixg,iyg. The unscaled distance */
  709. X/* along ixg,iyg is returned as dist */
  710. X
  711. X#include "plplot.h"
  712. X
  713. Xvoid plccal(pts,nx,ny,zlev,ix,iy,ixg,iyg,dist)
  714. Xint nx,ny,ix,iy,ixg,iyg;
  715. Xfloat *pts,zlev,*dist;
  716. X{
  717. X      int ia,ib;
  718. X      float dbot, dtop, pmid, qmid, zmid;
  719. X
  720. X      ia = ix+ixg;
  721. X      ib = iy+iyg;
  722. X      if (ixg == 0 || iyg == 0) {
  723. X        dtop = zlev - *(pts+(ix-1)*ny+iy-1);
  724. X        dbot = *(pts+(ia-1)*ny+ib-1) - *(pts+(ix-1)*ny+iy-1);
  725. X        *dist = 0.0;
  726. X        if (dbot != 0.0) *dist = dtop/dbot;
  727. X      }
  728. X      else {
  729. X        pmid = *(pts+(ix-1)*ny+iy-1) + *(pts+(ia-1)*ny+ib-1);
  730. X        qmid = *(pts+(ix-1)*ny+ib-1) + *(pts+(ia-1)*ny+iy-1);
  731. X        zmid = (pmid+qmid)/4.0;
  732. X        if (zmid >= zlev) {
  733. X          dtop = zlev - *(pts+(ix-1)*ny+iy-1);
  734. X          dbot = zmid - *(pts+(ix-1)*ny+iy-1);
  735. X          *dist = 0.0;
  736. X          if (dbot != 0.0) *dist = 0.5*dtop/dbot;
  737. X        }
  738. X        else {
  739. X          dtop = zlev-zmid;
  740. X          dbot = *(pts+(ia-1)*ny+ib-1) - zmid;
  741. X          *dist = 0.5;
  742. X          if (dbot != 0.0) *dist = 0.5 + 0.5*dtop/dbot;
  743. X        }
  744. X      }
  745. X}
  746. SHAR_EOF
  747. echo "extracting plclr.c"
  748. sed 's/^X//' << \SHAR_EOF > plclr.c
  749. X#include "plplot.h"
  750. X
  751. Xvoid plclr()
  752. X{
  753. X      int level;
  754. X      glev(&level);
  755. X      if (level < 1) fatal("Please call PLSTAR before calling PLCLR.");
  756. X
  757. X      grclr();
  758. X}
  759. SHAR_EOF
  760. echo "extracting plcntr.c"
  761. sed 's/^X//' << \SHAR_EOF > plcntr.c
  762. X/* Contour "ny" by "nx" real array "points" at the level "zlev" */
  763. X/* points is a pointer to a 2d array of nx by ny points. */
  764. X/* iscan has nx elements. ixstor and iystor each have nstor elements. */
  765. X
  766. X#include "plplot.h"
  767. X
  768. Xvoid plcntr(points,nx,ny,kx,lx,ky,ly,zlev,iscan,ixstor,iystor,nstor,tr)
  769. Xint nx, ny, ky, ly, kx, lx, nstor;
  770. Xfloat zlev, *points;
  771. Xint iscan[], ixstor[], iystor[];
  772. Xvoid (*tr)();
  773. X{
  774. X      int kcol, krow, kstor, kscan, iwbeg, ixbeg, iybeg, izbeg;
  775. X      int iboun, iw, ix, iy, iz, ifirst, istep, ixgo, iygo;
  776. X      int l, ixg, iyg, ia, ib, ixt, iyt, jstor, next;
  777. X      float dist, dx, dy, xnew, ynew, x, y;
  778. X      float xlas=0., ylas=0., tpx, tpy, xt, yt;
  779. X
  780. X      /* Initialize memory pointers */
  781. X
  782. X      kstor = 0;
  783. X      kscan = 0;
  784. X
  785. X      for (krow=ky; krow<=ly; krow++) {
  786. X        for (kcol=kx+1; kcol <= lx; kcol++)  {
  787. X
  788. X          /* Check if a contour has been crossed */
  789. X
  790. X          x = *(points + (kcol-2)*ny + krow-1);
  791. X          y = *(points + (kcol-1)*ny + krow-1);
  792. X          if (x < zlev && y >= zlev) {
  793. X            ixbeg = kcol-1;
  794. X            iwbeg = kcol;
  795. X          }
  796. X          else if (y < zlev && x >= zlev) {
  797. X            ixbeg = kcol;
  798. X            iwbeg = kcol-1;
  799. X          }
  800. X          else
  801. X            goto lab70;
  802. X
  803. X          iybeg = krow;
  804. X          izbeg = krow;
  805. X
  806. X          /* Yes, a contour has been crossed. Check to see if it */
  807. X          /* is a new one. */
  808. X
  809. X          for(l=0;l<kscan;l++)
  810. X            if (ixbeg == iscan[l]) goto lab70;
  811. X
  812. X          /* Here is the section which follows and draws a contour */
  813. X
  814. X          for (iboun=1; iboun>= -1; iboun -= 2) {
  815. X
  816. X            /* Set up starting point and initial search directions */
  817. X
  818. X            ix = ixbeg;
  819. X            iy = iybeg;
  820. X            iw = iwbeg;
  821. X            iz = izbeg;
  822. X            ifirst = 1;
  823. X            istep = 0;
  824. X            ixgo = iw - ix;
  825. X            iygo = iz - iy;
  826. X
  827. Xlab20:
  828. X              plccal(points,nx,ny,zlev,ix,iy,ixgo,iygo,&dist);
  829. X              dx = dist * ixgo;
  830. X              dy = dist * iygo;
  831. X              xnew = ix+dx;
  832. X              ynew = iy+dy;
  833. X
  834. X             /* Has a step occured in search? */
  835. X
  836. X              if (istep != 0) {
  837. X                if (ixgo*iygo == 0) {
  838. X
  839. X                  /* This was a diagonal step, so interpolate missed */
  840. X                  /* point, rotating 45 degrees to get it */
  841. X
  842. X                  ixg = ixgo;
  843. X                  iyg = iygo;
  844. X                  plr45(&ixg,&iyg,iboun);
  845. X                  ia = iw-ixg;
  846. X                  ib = iz-iyg;
  847. X                  plccal(points,nx,ny,zlev,ia,ib,ixg,iyg,&dist);
  848. X                  (*tr)(xlas,ylas,&tpx,&tpy);
  849. X                  drawor(tpx,tpy);
  850. X                  dx = dist*ixg;
  851. X                  dy = dist*iyg;
  852. X                  xlas = ia+dx;
  853. X                  ylas = ib+dy;
  854. X                }
  855. X                else {
  856. X                  if (dist > 0.5) {
  857. X                    xt = xlas;
  858. X                    xlas = xnew;
  859. X                    xnew = xt;
  860. X                    yt = ylas;
  861. X                    ylas = ynew;
  862. X                    ynew = yt;
  863. X                  }
  864. X                }
  865. X              }
  866. X              if (ifirst != 1) {
  867. X                (*tr)(xlas,ylas,&tpx,&tpy);
  868. X                drawor(tpx,tpy);
  869. X              }
  870. X              else {
  871. X                (*tr)(xnew,ynew,&tpx,&tpy);
  872. X                movwor(tpx,tpy);
  873. X              }
  874. X              xlas = xnew;
  875. X              ylas = ynew;
  876. X
  877. X              /* Check if the contour is closed */
  878. X
  879. X              if (ifirst != 1 && ix == ixbeg && iy == iybeg
  880. X                  && iw == iwbeg && iz == izbeg) {
  881. X                (*tr)(xlas,ylas,&tpx,&tpy);
  882. X                drawor(tpx,tpy);
  883. X                goto lab70;
  884. X              }
  885. X              ifirst = 0;
  886. X
  887. X              /* Now the rotation */
  888. X
  889. X              istep = 0;
  890. X              plr45(&ixgo,&iygo,iboun);
  891. X              iw = ix+ixgo;
  892. X              iz = iy+iygo;
  893. X
  894. X              /* Check if out of bounds */
  895. X
  896. X              if (iw<kx || iw>lx || iz<ky || iz>ly) goto  lab50;
  897. X
  898. X              /* Has contact been lost with the contour? */
  899. X
  900. X              if (*(points+(iw-1)*ny+iz-1) < zlev) {
  901. X
  902. X                /* Yes, lost contact => step to new centre */
  903. X
  904. X                istep = 1;
  905. X                ix = iw;
  906. X                iy = iz;
  907. X                plr135(&ixgo,&iygo,iboun);
  908. X                iw = ix+ixgo;
  909. X                iz = iy+iygo;
  910. X
  911. X                /* And do the contour memory */
  912. X
  913. X                if (iy == krow) {
  914. X                  kscan = kscan+1;
  915. X                  iscan[kscan-1] = ix;
  916. X                }
  917. X                else if (iy>krow) {
  918. X                  kstor = kstor+1;
  919. X                  if (kstor>nstor) {
  920. X                    fatal("Heap exhausted in PLCONT.");
  921. X                    goto lab70;
  922. X                  }
  923. X                  ixstor[kstor-1] = ix;
  924. X                  iystor[kstor-1] = iy;
  925. X                }
  926. X              }
  927. X            goto lab20;
  928. Xlab50:
  929. X            /* Reach here only if boundary encountered - Draw last bit */
  930. X
  931. X            (*tr)(xnew,ynew,&tpx,&tpy);
  932. X            drawor(tpx,tpy);
  933. X          }
  934. Xlab70:
  935. X          ;    /* Null statement to carry label */
  936. X        }
  937. X
  938. X        /* Search of row complete - set up memory of next row in iscan and */
  939. X        /* edit ixstor and iystor */
  940. X
  941. X        if (krow<ny) {
  942. X          jstor = 0;
  943. X          kscan = 0;
  944. X          next = krow+1;
  945. X          for (l=1; l<=kstor; l++) {
  946. X            ixt = ixstor[l-1];
  947. X            iyt = iystor[l-1];
  948. X
  949. X            /* Memory of next row into iscan */
  950. X
  951. X            if (iyt == next) {
  952. X              kscan = kscan+1;
  953. X              iscan[kscan-1] = ixt;
  954. X      
  955. X            /* Retain memory of rows to come, and forget rest */
  956. X
  957. X            }
  958. X            else if (iyt>next) {
  959. X              jstor = jstor+1;
  960. X              ixstor[jstor-1] = ixt;
  961. X              iystor[jstor-1] = iyt;
  962. X            }
  963. X          }
  964. X          kstor = jstor;
  965. X        }
  966. X      }
  967. X}
  968. SHAR_EOF
  969. echo "extracting plcol.c"
  970. sed 's/^X//' << \SHAR_EOF > plcol.c
  971. X/* Sets line colour */
  972. X
  973. X#include "plplot.h"
  974. X
  975. Xvoid plcol(colour)
  976. Xint colour;
  977. X{
  978. X      int font,col;
  979. X
  980. X      int level;
  981. X      glev(&level);
  982. X      if (level < 1)  fatal("Please call PLSTAR before calling PLCOL.");
  983. X      if (colour < 0)  fatal("Invalid colour in PLCOL.");
  984. X
  985. X      gatt(&font,&col);
  986. X      satt(font,colour);
  987. X      grcol();
  988. X}
  989. SHAR_EOF
  990. echo "extracting plcont.c"
  991. sed 's/^X//' << \SHAR_EOF > plcont.c
  992. X/* Draws a contour plot from data in z(nx,ny), using the subarray */
  993. X/* from kx to lx in the x direction and from ky to ly in the y */
  994. X/* direction. The array of contour levels is clevel(nlevel), and */
  995. X/* "tr" is the name of a subroutine which transforms array indicies */
  996. X/* into world coordinates */
  997. X
  998. X#include <stdio.h>
  999. X#include <stdlib.h>
  1000. X#include "plplot.h"
  1001. X#include "declare.h"
  1002. X
  1003. Xvoid plcont(z,nx,ny,kx,lx,ky,ly,clevel,nlevel,tr)
  1004. Xint nx, ny, kx, lx, ky, ly, nlevel;
  1005. Xfloat *z, clevel[];
  1006. Xvoid (*tr)();
  1007. X{
  1008. X      int i, mx, my, nstor;
  1009. X
  1010. X      mx = lx - kx + 1;
  1011. X      my = ly - ky + 1;
  1012. X
  1013. X      if (kx < 1 || lx > nx || kx >= lx || ky < 1 || ky > ny || ky >= ly)
  1014. X               fatal("Argument error in PLCONT");
  1015. X      
  1016. X      nstor = mx*my/5;
  1017. X
  1018. X      if( heapc != NULL)
  1019. X         free(heapc);
  1020. X      if(( heapc = (int *)malloc((mx+2*nstor)*sizeof(int))) == NULL)
  1021. X         fatal("Not enough heap space in PLCONT.");
  1022. X
  1023. X      for (i=0; i<nlevel; i++)
  1024. X        plcntr(z,nx,ny,kx,lx,ky,ly,clevel[i],&heapc[0],
  1025. X               &heapc[nx],&heapc[nx+nstor],nstor,tr);
  1026. X
  1027. X}
  1028. SHAR_EOF
  1029. echo "extracting plcvec.c"
  1030. sed 's/^X//' << \SHAR_EOF > plcvec.c
  1031. X/* Gets the character digitisation of Hershey table entry "char" */
  1032. X/* Returns 1 if there is a valid entry */
  1033. X
  1034. Xextern short int *buffer[];
  1035. Xextern int *findex[];
  1036. X
  1037. X#include "plplot.h"
  1038. X
  1039. Xint plcvec(ch,xygrid)
  1040. Xint ch;
  1041. Xshort int xygrid[];
  1042. X{
  1043. X
  1044. X      int nc1, nc2, k, ib, ix, iy;
  1045. X
  1046. X      nc1=1;
  1047. X      nc2=3000;
  1048. X      if (ch < nc1 || ch > nc2) return(0);
  1049. X      ib = *(findex[(ch-nc1)/100] + (ch-nc1)%100);
  1050. X      if (ib == 0) return(0);
  1051. X
  1052. X      k=1;
  1053. X      xygrid[k-1]= *(buffer[(ib-1)/100] + (ib-1)%100);
  1054. X
  1055. X      k=k+1;
  1056. X      do {
  1057. X        ib=ib+1;
  1058. X        ix= *(buffer[(ib-1)/100]+(ib-1)%100)/128 - 64;
  1059. X        xygrid[k-1]=ix;
  1060. X        k=k+1;
  1061. X        iy = *(buffer[(ib-1)/100]+(ib-1)%100)%128 - 64;
  1062. X        xygrid[k-1]=iy;
  1063. X        k=k+1;
  1064. X      } while (ix != -64 || iy != -64);
  1065. X
  1066. X      return(1);
  1067. X
  1068. X} 
  1069. SHAR_EOF
  1070. echo "extracting pldeco.c"
  1071. sed 's/^X//' << \SHAR_EOF > pldeco.c
  1072. X/* Decode a character string, and return an array of integer symbol */
  1073. X/* numbers. This routine is responsible for interpreting all escape */
  1074. X/* sequences. At present the following escape sequences are defined */
  1075. X/* (the letter following the \ may be either upper or lower case): */
  1076. X
  1077. X/* \u       :      up one level (returns -1) */
  1078. X/* \d       :      down one level (returns -2) */
  1079. X/* \b       :      backspace (returns -3) */
  1080. X/* \+       :      toggles overline mode (returns -4) */
  1081. X/* \-       :      toggles underline mode (returns -5) */
  1082. X/* \\       :      \, returns the code for backslash */
  1083. X/* \gx      :      greek letter corresponding to roman letter x */
  1084. X/* \fn      :      switch to Normal font */
  1085. X/* \fr      :      switch to Roman font */
  1086. X/* \fi      :      switch to Italic font */
  1087. X/* \fs      :      switch to Script font */
  1088. X/* \(nnn)   :      Hershey symbol number nnn (any number of digits) */
  1089. X
  1090. X#include "plplot.h"
  1091. X#include <stdio.h>    /* include for definition of NULL */
  1092. X#include <string.h>
  1093. X
  1094. Xstatic char font[] = "nrisnris";
  1095. Xstatic char greek[] = "ABGDEZYHIKLMNCOPRSTUFXQWabgdezyhiklmncoprstufxqw";
  1096. X
  1097. Xextern short int *hersh[];
  1098. X
  1099. Xvoid pldeco(symbol,length,text)
  1100. Xint symbol[],*length;
  1101. Xchar text[];
  1102. X{
  1103. X      int ch,icol,ifont,ig,j,lentxt;
  1104. X      char test;
  1105. X
  1106. X      /* Initialize parameters. */
  1107. X
  1108. X      lentxt=strlen(text);
  1109. X      *length=0;
  1110. X      j=0;
  1111. X      gatt(&ifont,&icol);
  1112. X
  1113. X      /* Get next character; treat non-printing characters as spaces. */
  1114. X
  1115. Xlab100:
  1116. X      j=j+1;
  1117. X      if (j>lentxt) return;
  1118. X      test=text[j-1];
  1119. X      ch=test;
  1120. X      if (ch<0)   ch = 32;
  1121. X
  1122. X      if (ch>175) ch = 32;
  1123. X
  1124. X      /* Test for escape sequence (\) */
  1125. X
  1126. X      if (ch=='\\') {
  1127. X        if ((lentxt-j)>=1) {
  1128. X          test=text[j];
  1129. X          if (test=='\\')
  1130. X            j = j+1;
  1131. X          else if (test=='U' || test=='u') {
  1132. X            *length = *length + 1;
  1133. X            symbol[*length-1] = -1;
  1134. X            j = j+1;
  1135. X            goto lab100;
  1136. X          }
  1137. X          else if (test=='D' || test=='d') {
  1138. X            *length = *length + 1;
  1139. X            symbol[*length-1] = -2;
  1140. X            j = j+1;
  1141. X            goto lab100;
  1142. X          }
  1143. X          else if (test=='B' || test=='b') {
  1144. X            *length = *length + 1;
  1145. X            symbol[*length-1] = -3;
  1146. X            j = j+1;
  1147. X            goto lab100;
  1148. X          }
  1149. X          else if (test=='+') {
  1150. X            *length = *length + 1;
  1151. X            symbol[*length-1] = -4;
  1152. X            j = j+1;
  1153. X            goto lab100;
  1154. X          }
  1155. X          else if (test=='-') {
  1156. X            *length = *length + 1;
  1157. X            symbol[*length-1] = -5;
  1158. X            j = j+1;
  1159. X            goto lab100;
  1160. X          }
  1161. X          else if (test=='(') {
  1162. X            *length = *length + 1;
  1163. X            symbol[*length-1] = 0;
  1164. X            j = j+2;
  1165. Xlab10:
  1166. X            if ('0'<=text[j-1] && text[j-1]<='9') {
  1167. X              symbol[*length-1] = symbol[*length-1]*10 + text[j-1] - '0';
  1168. X              j = j+1;
  1169. X              goto lab10;
  1170. X            }
  1171. X            if (text[j-1]!=')') j = j-1;
  1172. X            goto lab100;
  1173. X          }
  1174. X          else if (test=='F' || test=='f') {
  1175. X            test=text[j+1];
  1176. X            ifont = strpos(font,test) + 1;
  1177. X            if (ifont>4) ifont = ifont-4;
  1178. X            if (ifont==0) ifont = 1;
  1179. X            j = j+2;
  1180. X            goto lab100;
  1181. X          }
  1182. X          else if (test=='G' || test=='g') {
  1183. X            test=text[j+1];
  1184. X            ig = strpos(greek,test) + 1;
  1185. X            *length = *length + 1;
  1186. X            symbol[*length-1] = *(hersh[ifont-1] + 127 + ig);
  1187. X            j = j+2;
  1188. X            goto lab100;
  1189. X          }
  1190. X        }
  1191. X      }
  1192. X
  1193. X      /* Decode character. */
  1194. X
  1195. X      *length = *length + 1;
  1196. X      symbol[*length-1] = *(hersh[ifont-1]+ch);
  1197. X      goto lab100;
  1198. X}
  1199. SHAR_EOF
  1200. echo "extracting pldtik.c"
  1201. sed 's/^X//' << \SHAR_EOF > pldtik.c
  1202. X/* If tick == 0, this works out a "nice" interval, so that there */
  1203. X/* are between 3 and 7.5 major tick intervals in the input range */
  1204. X/* "vmin" to "vmax". Using this value for the tick interval or   */
  1205. X/* supplied value, it also computes "prec" which specifies       */
  1206. X/* the number of places that should be written after the decimal */
  1207. X/* point. The recommended number of subticks is returned in      */
  1208. X/* "nsubt" unless the routine is entered with a non-zero value   */
  1209. X/* of "nsubt". The output variable "mode" is set to 0 if         */
  1210. X/* labels are to be written in floating-point format, or to 1 if */
  1211. X/* they are to be written in fixed-point format.                 */
  1212. X                                                                
  1213. X#include "plplot.h"
  1214. X#include <math.h>
  1215. X
  1216. Xvoid pldtik(vmin, vmax, tick, nsubt, mode, prec)
  1217. Xfloat vmin, vmax, *tick;
  1218. Xint *nsubt, *mode, *prec;
  1219. X{
  1220. X      
  1221. X      float t1, t2, vmod;
  1222. X      int msd, np, ns;
  1223. X
  1224. X      vmod = max(fabs(vmin),fabs(vmax));
  1225. X      *mode = 0;
  1226. X      if (vmod < 1.0e-2 || vmod > 1.0e6) *mode = 1;
  1227. X      t1 = (float)log10(vmod);
  1228. X      msd = (int)t1;
  1229. X
  1230. X      t1 = (float)log10(fabs(vmax-vmin));
  1231. X      np = (int)t1;
  1232. X      t1 = t1 - np;
  1233. X      
  1234. X      if (t1 > 0.7781512503) {
  1235. X        t2 = 2.0 ;
  1236. X        ns = 4;
  1237. X      }
  1238. X      else if (t1 > 0.4771212549) {
  1239. X        t2 = 1.0 ;
  1240. X        ns = 5;
  1241. X      }
  1242. X      else if (t1 > 0.1760912591) {
  1243. X        t2 = 5.0;
  1244. X        ns = 5;
  1245. X        np = np-1;
  1246. X      }
  1247. X      else  {
  1248. X        t2 = 2.0;
  1249. X        ns = 4;
  1250. X        np = np-1;
  1251. X      }
  1252. X
  1253. X      if (*tick == 0.0) {
  1254. X        *tick = t2 * pow(10.0,(double)np);
  1255. X        if (vmin > vmax) *tick = -*tick;
  1256. X        if (*nsubt == 0) *nsubt = ns;
  1257. X        if (*mode != 0) 
  1258. X          *prec = msd - np;
  1259. X        else
  1260. X          *prec = max(-np,0);
  1261. X      }
  1262. X      else  {
  1263. X        t1 = (float)log10(fabs(*tick));
  1264. X        np = (int)t1;
  1265. X        if (*mode != 0) 
  1266. X          *prec = msd - np + 1;
  1267. X        else
  1268. X          *prec = max(-np+1,0);
  1269. X      }
  1270. X}
  1271. X
  1272. SHAR_EOF
  1273. echo "extracting plend.c"
  1274. sed 's/^X//' << \SHAR_EOF > plend.c
  1275. X/* Ends a plotting session */
  1276. X
  1277. X#include <stdio.h>
  1278. X#include <stdlib.h>
  1279. X#include "plplot.h"
  1280. X#include "declare.h"
  1281. X
  1282. Xvoid plend()
  1283. X{
  1284. X      int dev, term, gra, level;
  1285. X      
  1286. X      glev(&level);
  1287. X      if (level == 0) return;
  1288. X      gdev(&dev,&term,&gra);
  1289. X      if( heap3 != NULL) free((void *)heap3);
  1290. X      if( heapc != NULL) free((void *)heapc);
  1291. X      if (gra != 0) pltext();
  1292. X      grtidy();
  1293. X      slev(0);
  1294. X}
  1295. SHAR_EOF
  1296. echo "extracting plenv.c"
  1297. sed 's/^X//' << \SHAR_EOF > plenv.c
  1298. X/* Simple interface for defining viewport and window. If "just"=1,  */
  1299. X/* X and Y scales will be the same, otherwise they are scaled       */
  1300. X/* independently. The "axis" parameter is interpreted as follows:   */
  1301. X/* axis=-2 : draw no box, axis or labels                            */
  1302. X/* axis=-1 : draw box only                                          */
  1303. X/* axis= 0 : Draw box and label with coordinates                    */
  1304. X/* axis= 1 : Also draw the coordinate axes                          */
  1305. X/* axis= 2 : Draw a grid at major tick positions                    */
  1306. X/* axis=10 : Logarithmic X axis, L!=r Y axis, No X=0 axis         */
  1307. X/* axis=11 : Logarithmic X axis, L!=r Y axis, X=0 axis            */
  1308. X/* axis=20 : L!=r X axis, Logarithmic Y axis, No Y=0 axis         */
  1309. X/* axis=21 : L!=r X axis, Logarithmic Y axis, Y=0 axis            */
  1310. X/* axis=30 : Logarithmic X and Y axes                               */
  1311. X
  1312. X#include "plplot.h"
  1313. X#include <math.h>
  1314. X
  1315. Xvoid plenv(xmin,xmax,ymin,ymax,just,axis)
  1316. Xint just,axis;
  1317. Xfloat xmin, xmax, ymin, ymax;
  1318. X{
  1319. X    int level;
  1320. X    float chrdef, chrht;
  1321. X    float lb, rb, tb, bb, dx, dy;
  1322. X    float xsize, ysize, xscale, yscale;
  1323. X    float spxmin, spxmax, spymin, spymax;
  1324. X    float vpxmin, vpxmax, vpymin, vpymax;
  1325. X    float scale;
  1326. X
  1327. X    glev(&level);
  1328. X    if (level < 1) fatal("Please call PLSTAR before PLENV.");
  1329. X    
  1330. X    if (xmin == xmax) fatal("Invalid xmin and xmax arguments in PLENV");
  1331. X    if (ymin == ymax) fatal("Invalid ymin and ymax arguments in PLENV");
  1332. X    if ((just != 0) && (just != 1)) fatal("Invalid just option in PLENV");
  1333. X
  1334. X
  1335. X    pladv(0);
  1336. X    if (just == 0)
  1337. X      plvsta();
  1338. X    else {
  1339. X      gchr(&chrdef,&chrht);
  1340. X      lb = 7.0 * chrht;
  1341. X      rb = 4.0 * chrht;
  1342. X      tb = 4.0 * chrht;
  1343. X      bb = 4.0 * chrht;
  1344. X      dx = fabs(xmax-xmin);
  1345. X      dy = fabs(ymax-ymin);
  1346. X      plgspa(&spxmin,&spxmax,&spymin,&spymax);
  1347. X      xsize = spxmax - spxmin;
  1348. X      ysize = spymax - spymin;
  1349. X      xscale = dx/(xsize - lb - rb);
  1350. X      yscale = dy/(ysize - tb - bb);
  1351. X      scale = max(xscale,yscale);
  1352. X      vpxmin = max(lb,0.5*(xsize - dx/scale));
  1353. X      vpxmax = vpxmin + (dx/scale);
  1354. X      vpymin = max(bb,0.5*(ysize - dy/scale));
  1355. X      vpymax = vpymin + (dy/scale);
  1356. X      plsvpa(vpxmin,vpxmax,vpymin,vpymax);
  1357. X    }
  1358. X    plwind(xmin,xmax,ymin,ymax);
  1359. X    if (axis == -2)
  1360. X       ;
  1361. X    else if (axis == -1)
  1362. X       plbox("bc",0.0,0,"bc",0.0,0);
  1363. X    else if (axis == 0) 
  1364. X       plbox("bcnst",0.0,0,"bcnstv",0.0,0);
  1365. X    else if (axis == 1) 
  1366. X       plbox("abcnst",0.0,0,"abcnstv",0.0,0);
  1367. X    else if (axis == 2) 
  1368. X       plbox("abcgnst",0.0,0,"abcgnstv",0.0,0);
  1369. X    else if (axis == 10) 
  1370. X       plbox("bclnst",0.0,0,"bcnstv",0.0,0);
  1371. X    else if (axis == 11) 
  1372. X       plbox("bclnst",0.0,0,"abcnstv",0.0,0);
  1373. X    else if (axis == 20) 
  1374. X       plbox("bcnst",0.0,0,"bclnstv",0.0,0);
  1375. X    else if (axis == 21) 
  1376. X       plbox("bcnst",0.0,0,"abclnstv",0.0,0);
  1377. X    else if (axis == 30) 
  1378. X       plbox("bclnst",0.0,0,"bclnstv",0.0,0);
  1379. X    else
  1380. X       fatal("Invalid axis argument in plenv");
  1381. X}
  1382. SHAR_EOF
  1383. echo "extracting plerrx.c"
  1384. sed 's/^X//' << \SHAR_EOF > plerrx.c
  1385. X/* Plots horizontal error bars (xmin(i),y(i)) to (xmax(i),y(i)) */
  1386. X
  1387. X#include "plplot.h"
  1388. X
  1389. Xvoid plerrx(n,xmin,xmax,y)
  1390. Xint n;
  1391. Xfloat xmin[], xmax[], y[];
  1392. X{
  1393. X      int i, level;
  1394. X
  1395. X      glev(&level);
  1396. X      if (level < 3) fatal("Please set up window before calling PLERRX.");
  1397. X      for (i=0;i<n;i++)
  1398. X        plerx1(xmin[i],xmax[i],y[i]);
  1399. X}
  1400. SHAR_EOF
  1401. echo "extracting plerry.c"
  1402. sed 's/^X//' << \SHAR_EOF > plerry.c
  1403. X/* Plots vertical error bars (x,ymin(i)) to (x(i),ymax(i)) */
  1404. X
  1405. X#include "plplot.h"
  1406. X
  1407. Xvoid plerry(n,x,ymin,ymax)
  1408. Xint n;
  1409. Xfloat x[], ymin[], ymax[];
  1410. X{
  1411. X      int i, level;
  1412. X
  1413. X      glev(&level);
  1414. X      if (level < 3) fatal("Please set up window before calling PLERRY.");
  1415. X      for(i=0; i<n; i++)
  1416. X        plery1(x[i],ymin[i],ymax[i]);
  1417. X}
  1418. SHAR_EOF
  1419. echo "extracting plerx1.c"
  1420. sed 's/^X//' << \SHAR_EOF > plerx1.c
  1421. X/* Plots single horizontal error bar */
  1422. X
  1423. X#include "plplot.h"
  1424. X#include <math.h>
  1425. X
  1426. Xvoid plerx1(xmin,xmax,y)
  1427. Xfloat xmin, xmax, y;
  1428. X{
  1429. X      float mindef, minht, xpmm, ypmm;
  1430. X      int yminor;
  1431. X      
  1432. X      gmin(&mindef,&minht);
  1433. X      gpixmm(&xpmm,&ypmm);
  1434. X      yminor = max(1.0,minht*ypmm);
  1435. X      movwor(xmin,y);
  1436. X      plxtik(wcpcx(xmin),wcpcy(y),yminor,yminor);
  1437. X      drawor(xmax,y);
  1438. X      plxtik(wcpcx(xmax),wcpcy(y),yminor,yminor);
  1439. X}
  1440. SHAR_EOF
  1441. echo "extracting plery1.c"
  1442. sed 's/^X//' << \SHAR_EOF > plery1.c
  1443. X/* Plots single vertical error bar */
  1444. X
  1445. X#include "plplot.h"
  1446. X#include <math.h>
  1447. X
  1448. Xvoid plery1(x,ymin,ymax)
  1449. Xfloat x, ymin, ymax;
  1450. X{
  1451. X      float mindef, minht, xpmm, ypmm;
  1452. X      int xminor;
  1453. X      
  1454. X      gmin(&mindef,&minht);
  1455. X      gpixmm(&xpmm,&ypmm);
  1456. X      xminor = max(1.0,minht*xpmm);
  1457. X      movwor(x,ymin);
  1458. X      plytik(wcpcx(x),wcpcy(ymin),xminor,xminor);
  1459. X      drawor(x,ymax);
  1460. X      plytik(wcpcx(x),wcpcy(ymax),xminor,xminor);
  1461. X}
  1462. SHAR_EOF
  1463. echo "extracting plfont.c"
  1464. sed 's/^X//' << \SHAR_EOF > plfont.c
  1465. X#include "plplot.h"
  1466. X
  1467. Xvoid plfont(ifont)
  1468. Xint ifont;
  1469. X{
  1470. X      int ifnt,icol;
  1471. X
  1472. X      int level;
  1473. X      glev(&level);
  1474. X      if (level < 1) fatal("Please call PLSTAR before calling PLFONT.");
  1475. X
  1476. X      if (ifont < 1 || ifont > 4) fatal("Invalid font in PLFONT");
  1477. X      gatt(&ifnt,&icol);
  1478. X      satt(ifont,icol);
  1479. X}
  1480. SHAR_EOF
  1481. echo "extracting plform.c"
  1482. sed 's/^X//' << \SHAR_EOF > plform.c
  1483. X/* Formats a floating point value in one of the following formats   */
  1484. X/* (i)  If mode == 0, use floating point format with "precision"    */
  1485. X/*      places after the decimal point.                             */
  1486. X/* (ii) If mode == 1, use scientific notation with one place before */
  1487. X/*      the decimal point and "precision" places after.             */
  1488. X
  1489. X#include "plplot.h"
  1490. X#include <stdio.h>
  1491. X#include <string.h>
  1492. X
  1493. Xvoid plform(value,mode,prec,result)
  1494. Xfloat value;
  1495. Xint mode, prec;
  1496. Xchar *result;
  1497. X{
  1498. X      int j, expon;
  1499. X      char form[10];
  1500. X      char temp[30];
  1501. X
  1502. X      if (mode == 0) {
  1503. X        sprintf(form,"%%-.%df",prec);
  1504. X        sprintf(temp,form,value);
  1505. X        strcpy(result,temp);
  1506. X      }
  1507. X      else {
  1508. X        sprintf(form,"%%-.%dE",prec);
  1509. X        sprintf(temp,form,value);
  1510. X        j = strpos(temp,'E') + 1;
  1511. X        if (j == 0) fatal("Unrecognized scientific notation");
  1512. X        sscanf(&temp[j],"%d",&expon);
  1513. X        sprintf(form,"%-d",expon);
  1514. X        strcpy(&temp[j-1],"x10\\u");
  1515. X        strcat(temp,form);
  1516. X        strcpy(result,temp);
  1517. X      }
  1518. X}
  1519. X
  1520. SHAR_EOF
  1521. echo "extracting plgra.c"
  1522. sed 's/^X//' << \SHAR_EOF > plgra.c
  1523. X/* Switches to graphics mode */
  1524. X
  1525. X#include "plplot.h"
  1526. X
  1527. Xvoid plgra()
  1528. X{
  1529. X      int level;
  1530. X      glev(&level);
  1531. X      if (level < 1) fatal("Please call PLSTAR before PLGRA.");
  1532. X      grgra();
  1533. X}
  1534. SHAR_EOF
  1535. echo "extracting plgrid3.c"
  1536. sed 's/^X//' << \SHAR_EOF > plgrid3.c
  1537. X/* Routine to draw a grid around the back side of the 3d plot */
  1538. X/* wih hidden line removal */
  1539. X
  1540. X#include "plplot.h"
  1541. X#include <math.h>
  1542. X
  1543. Xvoid plgrid3(tick)
  1544. Xfloat tick;
  1545. X{
  1546. X    float xmin, ymin, zmin, xmax, ymax, zmax, zscale;
  1547. X    float cxx, cxy, cyx, cyy, cyz;
  1548. X    int u[3], v[3];
  1549. X    int nsub, mode, prec;
  1550. X    float tp;
  1551. X
  1552. X    gw3wc(&cxx,&cxy,&cyx,&cyy,&cyz);
  1553. X    gdom(&xmin,&xmax,&ymin,&ymax);
  1554. X    grange(&zscale,&zmin,&zmax);
  1555. X
  1556. X    nsub = 0;
  1557. X    pldtik(zmin,zmax,&tick,&nsub,&mode,&prec);
  1558. X    tp = tick * floor(zmin/tick) + tick;
  1559. X
  1560. X    if (cxx >= 0.0 && cxy <= 0.0)  {
  1561. X        while ( tp <= zmax ) {
  1562. X            u[0] = wcpcx(w3wcx(xmin,ymax,tp));
  1563. X            v[0] = wcpcy(w3wcy(xmin,ymax,tp));
  1564. X            u[1] = wcpcx(w3wcx(xmax,ymax,tp));
  1565. X            v[1] = wcpcy(w3wcy(xmax,ymax,tp));
  1566. X            u[2] = wcpcx(w3wcx(xmax,ymin,tp));
  1567. X            v[2] = wcpcy(w3wcy(xmax,ymin,tp));
  1568. X            plnxtv(u,v,3,2);
  1569. X
  1570. X            tp += tick;
  1571. X        }
  1572. X        u[0] = wcpcx(w3wcx(xmax,ymax,zmin));
  1573. X        v[0] = wcpcy(w3wcy(xmax,ymax,zmin));
  1574. X        u[1] = wcpcx(w3wcx(xmax,ymax,zmax));
  1575. X        v[1] = wcpcy(w3wcy(xmax,ymax,zmax));
  1576. X        plnxtv(u,v,2,2);
  1577. X    }
  1578. X    else if(cxx <= 0.0  && cxy <= 0.0)  {
  1579. X        while ( tp <= zmax ) {
  1580. X            u[0] = wcpcx(w3wcx(xmax,ymax,tp));
  1581. X            v[0] = wcpcy(w3wcy(xmax,ymax,tp));
  1582. X            u[1] = wcpcx(w3wcx(xmax,ymin,tp));
  1583. X            v[1] = wcpcy(w3wcy(xmax,ymin,tp));
  1584. X            u[2] = wcpcx(w3wcx(xmin,ymin,tp));
  1585. X            v[2] = wcpcy(w3wcy(xmin,ymin,tp));
  1586. X            plnxtv(u,v,3,2);
  1587. X
  1588. X            tp += tick;
  1589. X        }
  1590. X        u[0] = wcpcx(w3wcx(xmax,ymin,zmin));
  1591. X        v[0] = wcpcy(w3wcy(xmax,ymin,zmin));
  1592. X        u[1] = wcpcx(w3wcx(xmax,ymin,zmax));
  1593. X        v[1] = wcpcy(w3wcy(xmax,ymin,zmax));
  1594. X        plnxtv(u,v,2,2);
  1595. X    }
  1596. X    else if(cxx <= 0.0  && cxy >= 0.0)  {
  1597. X        while ( tp <= zmax ) {
  1598. X            u[0] = wcpcx(w3wcx(xmax,ymin,tp));
  1599. X            v[0] = wcpcy(w3wcy(xmax,ymin,tp));
  1600. X            u[1] = wcpcx(w3wcx(xmin,ymin,tp));
  1601. X            v[1] = wcpcy(w3wcy(xmin,ymin,tp));
  1602. X            u[2] = wcpcx(w3wcx(xmin,ymax,tp));
  1603. X            v[2] = wcpcy(w3wcy(xmin,ymax,tp));
  1604. X            plnxtv(u,v,3,2);
  1605. X
  1606. X            tp += tick;
  1607. X        }
  1608. X        u[0] = wcpcx(w3wcx(xmin,ymin,zmin));
  1609. X        v[0] = wcpcy(w3wcy(xmin,ymin,zmin));
  1610. X        u[1] = wcpcx(w3wcx(xmin,ymin,zmax));
  1611. X        v[1] = wcpcy(w3wcy(xmin,ymin,zmax));
  1612. X        plnxtv(u,v,2,2);
  1613. X    }
  1614. X    else if(cxx >= 0.0  && cxy >= 0.0)  {
  1615. X        while ( tp <= zmax ) {
  1616. X            u[0] = wcpcx(w3wcx(xmin,ymin,tp));
  1617. X            v[0] = wcpcy(w3wcy(xmin,ymin,tp));
  1618. X            u[1] = wcpcx(w3wcx(xmin,ymax,tp));
  1619. X            v[1] = wcpcy(w3wcy(xmin,ymax,tp));
  1620. X            u[2] = wcpcx(w3wcx(xmax,ymax,tp));
  1621. X            v[2] = wcpcy(w3wcy(xmax,ymax,tp));
  1622. X            plnxtv(u,v,3,2);
  1623. X
  1624. X            tp += tick;
  1625. X        }
  1626. X        u[0] = wcpcx(w3wcx(xmin,ymax,zmin));
  1627. X        v[0] = wcpcy(w3wcy(xmin,ymax,zmin));
  1628. X        u[1] = wcpcx(w3wcx(xmin,ymax,zmax));
  1629. X        v[1] = wcpcy(w3wcy(xmin,ymax,zmax));
  1630. X        plnxtv(u,v,2,2);
  1631. X    }
  1632. X}
  1633. SHAR_EOF
  1634. echo "extracting plgspa.c"
  1635. sed 's/^X//' << \SHAR_EOF > plgspa.c
  1636. X/* Gets subpage boundaries in absolute coordinates (mm from bottom */
  1637. X/* left-hand corner of page) */
  1638. X
  1639. X#include "plplot.h"
  1640. X
  1641. Xvoid plgspa(xmin,xmax,ymin,ymax)
  1642. Xfloat *xmin, *xmax, *ymin, *ymax;
  1643. X{
  1644. X      float spdxmi, spdxma, spdymi, spdyma;
  1645. X
  1646. X      int level;
  1647. X
  1648. X      glev(&level);
  1649. X      if (level < 1) fatal("Please call PLSTAR before PLGSPA.");
  1650. X      gspd(&spdxmi,&spdxma,&spdymi,&spdyma);
  1651. X      *xmin = dcmmx(spdxmi);
  1652. X      *xmax = dcmmx(spdxma);
  1653. X      *ymin = dcmmy(spdymi);
  1654. X      *ymax = dcmmy(spdyma);
  1655. X}
  1656. SHAR_EOF
  1657. echo "extracting plhist.c"
  1658. sed 's/^X//' << \SHAR_EOF > plhist.c
  1659. X/* Draws a histogram of n values of a variable in array data(1..n) */
  1660. X/* in the range datmin to datmax using nbin bins. If "oldwin" is   */
  1661. X/* true, the histogram is plotted in the current window. If not,   */
  1662. X/* the routine calls "plenv" to set up the graphics environment.   */
  1663. X
  1664. X#include "plplot.h"
  1665. X#include <math.h>
  1666. X
  1667. Xvoid plhist(n,data,datmin,datmax,nbin,oldwin)
  1668. Xint n, nbin;
  1669. Xint oldwin;
  1670. Xfloat data[], datmin, datmax;
  1671. X{
  1672. X      int i, bin, level;
  1673. X      float x[201], y[201], dx, ymax;
  1674. X      
  1675. X      glev(&level);
  1676. X      if (level<1) fatal("Please call PLSTAR before PLHIST.");
  1677. X      if (level<3 && oldwin)
  1678. X              fatal("Please set up window before calling PLHIST.");
  1679. X      
  1680. X      if (nbin < 1 || nbin > 200)
  1681. X              fatal("Cannot have <1 or >200 bins in PLHIST.");
  1682. X      if (datmin >= datmax)
  1683. X              fatal("Data range invalid in PLHIST.");
  1684. X      
  1685. X      dx = (datmax-datmin) / nbin;
  1686. X      for (i=0; i<=nbin; i++) {
  1687. X        x[i] = datmin + i*dx;
  1688. X        y[i] = 0.0;
  1689. X      }
  1690. X
  1691. X      for (i=0; i<n; i++)  {
  1692. X        bin = (data[i] - datmin)/dx;
  1693. X        if (bin >= 0 && bin < nbin) y[bin]++;
  1694. X      }
  1695. X
  1696. X      if (!oldwin) {
  1697. X        ymax = 0.0;
  1698. X        for (i=0; i<nbin; i++) ymax = max(ymax,y[i]);
  1699. X        plenv(datmin,datmax,0.0,1.1*ymax,0,0);
  1700. X      }
  1701. X         
  1702. X      plbin(nbin+1,x,y,0);
  1703. X}
  1704. SHAR_EOF
  1705. echo "extracting plhrsh.c"
  1706. sed 's/^X//' << \SHAR_EOF > plhrsh.c
  1707. X/* Writes the Hershey symbol "ch" centred at the physical */
  1708. X/* coordinate (x,y) */
  1709. X
  1710. X#include "plplot.h"
  1711. X
  1712. Xvoid plhrsh(ch,x,y)
  1713. Xint ch, x, y;
  1714. X{
  1715. X      int cx, cy, k, penup;
  1716. X      short int xygrid[300];
  1717. X      float symdef, symht, scale, xscale, yscale, xpmm, ypmm;
  1718. X
  1719. X      gsym(&symdef,&symht);
  1720. X      gpixmm(&xpmm,&ypmm);
  1721. X      k = 5;
  1722. X      penup = 1;
  1723. X      scale = 0.05 * symht;
  1724. X
  1725. X      if (!plcvec(ch,xygrid)) {
  1726. X        movphy(x,y);
  1727. X        return;
  1728. X      }
  1729. X      
  1730. X      /* Compute how many physical pixels correspond to a character pixel */
  1731. X
  1732. X      xscale = scale * xpmm;
  1733. X      yscale = scale * ypmm;
  1734. X
  1735. X      for(;;) {
  1736. X        cx = xygrid[k];
  1737. X        k = k+1;
  1738. X        cy = xygrid[k];
  1739. X        k = k+1;
  1740. X        if (cx == -64 && cy == -64) {
  1741. X          movphy(x,y);
  1742. X          return;
  1743. X        }
  1744. X        else if (cx == -64 && cy == 0) 
  1745. X          penup = 1;
  1746. X        else  {
  1747. X          if (penup != 0) {
  1748. X            movphy(round(x+xscale*cx),round(y+yscale*cy));
  1749. X            penup = 0;
  1750. X          }
  1751. X          else
  1752. X            draphy(round(x+xscale*cx),round(y+yscale*cy));
  1753. X        }
  1754. X      }
  1755. X}
  1756. SHAR_EOF
  1757. echo "extracting pljoin.c"
  1758. sed 's/^X//' << \SHAR_EOF > pljoin.c
  1759. X#include "plplot.h"
  1760. X
  1761. Xvoid pljoin(x1,y1,x2,y2)
  1762. Xfloat x1, x2, y1, y2;
  1763. X{
  1764. X   movwor(x1,y1);
  1765. X   drawor(x2,y2);
  1766. X}
  1767. SHAR_EOF
  1768. echo "extracting pllab.c"
  1769. sed 's/^X//' << \SHAR_EOF > pllab.c
  1770. X/* Simple routine for labelling graphs */
  1771. X
  1772. X#include "plplot.h"
  1773. X
  1774. Xvoid pllab(xlabel, ylabel, tlabel)
  1775. Xchar *xlabel, *ylabel, *tlabel;
  1776. X{
  1777. X      int level;
  1778. X      glev(&level);
  1779. X      if (level < 2) fatal("Please set up viewport before calling PLLAB.");
  1780. X
  1781. X      plmtex("t",2.0,0.5,0.5,tlabel);
  1782. X      plmtex("b",3.2,0.5,0.5,xlabel);
  1783. X      plmtex("l",5.0,0.5,0.5,ylabel);
  1784. X}
  1785. SHAR_EOF
  1786. echo "extracting pllclp.c"
  1787. sed 's/^X//' << \SHAR_EOF > pllclp.c
  1788. X/* Draws a (x1,y1) to (x2,y2) within the clip limits */
  1789. X
  1790. X#include "plplot.h"
  1791. X
  1792. X#define betw(ix,ia,ib) ((ix<=ia && ix>=ib) || (ix>=ia && ix<=ib))
  1793. X#define inside(ix,iy) (betw(ix,clpxmi,clpxma) && betw(iy,clpymi,clpyma))
  1794. X#define ixcut(iy) round((float)((x2-x1)*(iy-y1)+x1*(y2-y1))/(float)(y2-y1))
  1795. X#define iycut(ix) round((float)((y2-y1)*(ix-x1)+y1*(x2-x1))/(float)(x2-x1))
  1796. X
  1797. Xvoid pllclp(x1,y1,x2,y2)
  1798. Xint x1,y1,x2,y2;
  1799. X{
  1800. X      int xt[2],yt[2];
  1801. X      int it, k;
  1802. X      int clpxmi,clpxma,clpymi,clpyma;
  1803. X
  1804. X      gclp(&clpxmi,&clpxma,&clpymi,&clpyma);
  1805. X      k=0;
  1806. X      if (inside(x1,y1)) {
  1807. X        xt[k]=x1;
  1808. X        yt[k]=y1;
  1809. X        k=k+1;
  1810. X      }
  1811. X      if (inside(x2,y2)) {
  1812. X        xt[k]=x2;
  1813. X        yt[k]=y2;
  1814. X        k=k+1;
  1815. X      }
  1816. X      if (k == 2) goto draw;
  1817. X      if (y1 != y2) {
  1818. X        it=ixcut(clpymi);
  1819. X        if (inside(it,clpymi) && betw(clpymi,y1,y2)) {
  1820. X          xt[k]=it;
  1821. X          yt[k]=clpymi;
  1822. X          k=k+1;
  1823. X        }
  1824. X        if (k == 2) goto draw;
  1825. X        it=ixcut(clpyma);
  1826. X        if (inside(it,clpyma) && betw(clpyma,y1,y2)) {
  1827. X          xt[k]=it;
  1828. X          yt[k]=clpyma;
  1829. X          k=k+1;
  1830. X        }
  1831. X        if (k == 2) goto draw;
  1832. X      }
  1833. X      if (x1 != x2) {
  1834. X        it=iycut(clpxmi);
  1835. X        if (inside(clpxmi,it) && betw(clpxmi,x1,x2)) {
  1836. X          xt[k]=clpxmi;
  1837. X          yt[k]=it;
  1838. X          k=k+1;
  1839. X        }
  1840. X        if (k == 2) goto draw;
  1841. X        it=iycut(clpxma);
  1842. X        if (inside(clpxma,it) && betw(clpxma,x1,x2)) {
  1843. X          xt[k]=clpxma;
  1844. X          yt[k]=it;
  1845. X          k=k+1;
  1846. X        }
  1847. X        if (k == 2) goto draw;
  1848. X      }
  1849. Xdraw:
  1850. X      if (k == 2) genlin(xt[0],yt[0],xt[1],yt[1]);
  1851. X      scurr(x2,y2);
  1852. X} 
  1853. SHAR_EOF
  1854. echo "extracting plline.c"
  1855. sed 's/^X//' << \SHAR_EOF > plline.c
  1856. X#include "plplot.h"
  1857. X
  1858. Xvoid plline(n,x,y)
  1859. Xint n;
  1860. Xfloat x[],y[];
  1861. X{
  1862. X      int i,level;
  1863. X      glev(&level);
  1864. X      if (level<3) fatal("Please set up window before calling PLLINE.");
  1865. X      movwor(x[0],y[0]);
  1866. X      for(i=0; i<n; i++)
  1867. X        drawor(x[i],y[i]);
  1868. X}
  1869. SHAR_EOF
  1870. echo "extracting plmtex.c"
  1871. sed 's/^X//' << \SHAR_EOF > plmtex.c
  1872. X/* Prints out "text" at specified position relative to viewport       */
  1873. X/* (may be inside or outside)                                         */
  1874. X
  1875. X/* side   String which is one of the following:                       */
  1876. X/*        B or b  :  Bottom of viewport                               */
  1877. X/*        T or t  :  Top of viewport                                  */
  1878. X/*        L or l  :  Left of viewport                                 */
  1879. X/*        R or r  :  Right of viewport                                */
  1880. X/*        LV or lv : Left of viewport, vertical text                  */
  1881. X/*        RV or rv : Right of viewport, vertical text                 */
  1882. X/* disp   Displacement from specified edge of viewport, measured      */
  1883. X/*         outwards from the viewport in units of the current         */
  1884. X/*         character height. The CENTRELINES of the characters are    */
  1885. X/*         aligned with the specified position.                       */
  1886. X/* pos    Position of the reference point of the string relative      */
  1887. X/*         to the viewport edge, ranging from 0.0 (left-hand edge)    */
  1888. X/*         to 1.0 (right-hand edge)                                   */
  1889. X/* just   Justification of string relative to reference point         */
  1890. X/*         just = 0.0 => left hand edge of string is at reference     */
  1891. X/*         just = 1.0 => right hand edge of string is at reference    */
  1892. X/*         just = 0.5 => centre of string is at reference             */
  1893. X
  1894. X#include "plplot.h"
  1895. X
  1896. Xvoid plmtex(side,disp,pos,just,text)
  1897. Xchar side[], text[];
  1898. Xfloat disp, pos, just;
  1899. X{
  1900. X      int clpxmi, clpxma, clpymi, clpyma;
  1901. X      int sppxmi, sppxma, sppymi, sppyma;
  1902. X      int vert, refx, refy;
  1903. X      float shift, xform[4];
  1904. X      float vpdxmi, vpdxma, vpdymi, vpdyma;
  1905. X      float chrdef, chrht;
  1906. X      float mpxscl, mpxoff, mpyscl, mpyoff;
  1907. X
  1908. X      int level;
  1909. X      glev(&level);
  1910. X      if (level < 2) fatal("Please set up viewport before calling PLMTEX.");
  1911. X      
  1912. X      /* Open clip limits to subpage limits */
  1913. X
  1914. X      gclp(&clpxmi,&clpxma,&clpymi,&clpyma);
  1915. X      gspp(&sppxmi,&sppxma,&sppymi,&sppyma);
  1916. X      sclp(sppxmi,sppxma,sppymi,sppyma);
  1917. X
  1918. X      gvpd(&vpdxmi,&vpdxma,&vpdymi,&vpdyma);
  1919. X      gmp(&mpxscl,&mpxoff,&mpyscl,&mpyoff);
  1920. X      gchr(&chrdef,&chrht);
  1921. X
  1922. X      shift = 0.0;
  1923. X      if (just!=0.0) shift = just * plstrl(text);
  1924. X
  1925. X      if (strpos(side,'B')!=-1 || strpos(side,'b')!=-1) {
  1926. X        vert = 0;
  1927. X        refx = dcpcx(vpdxmi + (vpdxma-vpdxmi) * pos) - shift*mpxscl;
  1928. X        refy = mmpcy(dcmmy(vpdymi) - disp * chrht);
  1929. X      }
  1930. X      else if (strpos(side,'T')!=-1 || strpos(side,'t')!=-1) {
  1931. X        vert = 0;
  1932. X        refx = dcpcx(vpdxmi + (vpdxma-vpdxmi) * pos) - shift*mpxscl;
  1933. X        refy = mmpcy(dcmmy(vpdyma) + disp * chrht);
  1934. X      }
  1935. X      else if (stindex(side,"LV")!=-1 || stindex(side,"lv")!=-1) {   
  1936. X        vert = 0;
  1937. X        refy = dcpcy(vpdymi + (vpdyma-vpdymi) * pos);
  1938. X        refx = mmpcx(dcmmx(vpdxmi) - disp * chrht - shift);
  1939. X      }
  1940. X      else if (stindex(side,"RV")!=-1 || stindex(side,"rv")!=-1) {
  1941. X        vert = 0;
  1942. X        refy = dcpcy(vpdymi + (vpdyma-vpdymi) * pos);
  1943. X        refx = mmpcx(dcmmx(vpdxma) + disp * chrht - shift);
  1944. X      }
  1945. X      else if (strpos(side,'L')!=-1 || strpos(side,'l')!=-1) {   
  1946. X        vert = 1;
  1947. X        refy = dcpcy(vpdymi + (vpdyma-vpdymi) * pos) - shift*mpyscl;
  1948. X        refx = mmpcx(dcmmx(vpdxmi) - disp * chrht);
  1949. X      }
  1950. X      else if (strpos(side,'R')!=-1 || strpos(side,'r')!=-1) {
  1951. X        vert = 1;
  1952. X        refy = dcpcy(vpdymi + (vpdyma-vpdymi) * pos) - shift*mpyscl;
  1953. X        refx = mmpcx(dcmmx(vpdxma) + disp * chrht);
  1954. X      }
  1955. X      else {
  1956. X        sclp(clpxmi,clpxma,clpymi,clpyma);
  1957. X        return;
  1958. X      }
  1959. X
  1960. X      if (vert != 0) {
  1961. X        xform[0] = 0.0;
  1962. X        xform[1] = -1.0;
  1963. X        xform[2] = 1.0;
  1964. X        xform[3] = 0.0;
  1965. X      }
  1966. X      else {
  1967. X        xform[0] = 1.0;
  1968. X        xform[1] = 0.0;
  1969. X        xform[2] = 0.0;
  1970. X        xform[3] = 1.0;
  1971. X      }
  1972. X      plstr(0,xform,refx,refy,text);
  1973. X      sclp(clpxmi,clpxma,clpymi,clpyma);
  1974. X}
  1975. SHAR_EOF
  1976. echo "extracting plnxtv.c"
  1977. sed 's/^X//' << \SHAR_EOF > plnxtv.c
  1978. X/* Draws the next view of a 3-d plot. The physical coordinates of */
  1979. X/* the points for the next view are placed in the n points of arrays  */
  1980. X/* u and v. The silhouette found so far is stored in the heap as a */
  1981. X/* set of m peak points. */
  1982. X
  1983. X/* Define the heap size.  This can be increased if necessary.  Someday */
  1984. X/* I hope to just allocate a heap space of minimum required size.      */
  1985. X#define  heaps    4000
  1986. X
  1987. X#include <stdio.h>
  1988. X#include <stdlib.h>
  1989. X#include "plplot.h"
  1990. X#include "declare.h"
  1991. X
  1992. Xstatic int m, x, y;
  1993. X
  1994. Xvoid plnxtv(u,v,n,init)
  1995. Xint u[], v[], n, init;
  1996. X{
  1997. X      int xx;
  1998. X      int i, j, first;
  1999. X      int sx1, sx2, sy1, sy2;
  2000. X      int su1, su2, sv1, sv2;
  2001. X      int cx, cy, px, py;
  2002. X      int seg, ptold, lstold, pthi, pnewhi, newhi, change, ochange;
  2003. X      
  2004. X      first = 1;
  2005. X      pnewhi = 0;
  2006. X      
  2007. X      /* For the initial set of points, just display them and store them as */
  2008. X      /* the peak points. */
  2009. X
  2010. X      if (init == 1) {
  2011. X         if( heap3 == NULL)  /* heap not yet allocated so ... */
  2012. X            if(( heap3 = (int *)malloc(heaps*sizeof(int))) == NULL)
  2013. X               fatal("Not enough heap space in PLNXTV.");
  2014. X         y = heaps - n;
  2015. X         x = y - n;
  2016. X         movphy(u[0],v[0]);
  2017. X         heap3[x] = u[0];
  2018. X         heap3[y] = v[0];
  2019. X         for (i=1; i<n; i++){
  2020. X           draphy(u[i],v[i]);
  2021. X           heap3[x+i] = u[i];
  2022. X           heap3[y+i] = v[i];
  2023. X         }
  2024. X         m = n;
  2025. X         return;
  2026. X      }
  2027. X
  2028. X      /* Otherwise, we need to consider hidden-line removal problem. We scan */
  2029. X      /* over the points in both the old (i.e. heap3[x...] and heap3[y...]) and */
  2030. X      /* new (i.e. u[] and v[]) arrays in order of increasing x coordinate. */
  2031. X      /* At each stage, we find the line segment in the other array (if one */
  2032. X      /* exists) that straddles the x coordinate of the point. We */
  2033. X      /* have to determine if the point lies above or below the line segment, */
  2034. X      /* and to check if the below/above status has changed since the last */
  2035. X      /* point. */
  2036. X
  2037. X      /* If init = 2 we do not update the view, this is useful for drawing */
  2038. X      /* lines on the graph after we are done plotting points.  Hidden line */
  2039. X      /* removal is still done, but the view is not updated. */
  2040. X      xx = 0;
  2041. X      i = 0;
  2042. X      j = 0;
  2043. X
  2044. X      /* (heap3[x+i], heap3[y+i]) is the i'th point in the old array */
  2045. X      /* (u[j], v[j])           is the j'th point in the new array */
  2046. X
  2047. X      while (i < m || j < n) {
  2048. X
  2049. X        /* The coordinates of the point under consideration are (px,py). */
  2050. X        /* The line segment joins (sx1,sy1) to (sx2,sy2). */
  2051. X
  2052. X        /* "ptold" is true if the point lies in the old array. We set it */
  2053. X        /*  by comparing the x coordinates of the i'th old point */
  2054. X        /*  and the j'th new point, being careful if we have fallen past */
  2055. X        /*  the edges. Having found the point, load up the point and */
  2056. X        /*  segment coordinates appropriately. */
  2057. X 
  2058. X        ptold = ((heap3[x+i] < u[j] && i<m) || j>= n);
  2059. X        if (ptold) {
  2060. X          px = heap3[x+i];
  2061. X          py = heap3[y+i];
  2062. X          seg = j>0 && j<n;
  2063. X          if (seg) {
  2064. X            sx1 = u[j-1];
  2065. X            sy1 = v[j-1];
  2066. X            sx2 = u[j];
  2067. X            sy2 = v[j];
  2068. X          }
  2069. X        }
  2070. X        else {
  2071. X          px = u[j];
  2072. X          py = v[j];
  2073. X          seg = i>0 && i<m;
  2074. X          if (seg) {
  2075. X            sx1 = heap3[x+i-1];
  2076. X            sy1 = heap3[y+i-1];
  2077. X            sx2 = heap3[x+i];
  2078. X            sy2 = heap3[y+i];
  2079. X          }
  2080. X        }
  2081. X
  2082. X        /* Now determine if the point is higher than the segment, using the */
  2083. X        /* logical function "above". We also need to know if it is */
  2084. X        /* the old view or the new view that is higher. "newhi" is set true */
  2085. X        /* if the new view is higher than the old */
  2086. X
  2087. X        if(seg)
  2088. X            pthi = plabv(px,py,sx1,sy1,sx2,sy2);
  2089. X        else
  2090. X            pthi = 1;
  2091. X
  2092. X        newhi = (ptold && !pthi) || (!ptold && pthi);
  2093. X        change = (newhi && !pnewhi) || (!newhi && pnewhi);
  2094. X
  2095. X        /* There is a new intersection point to put in the peak array if the */
  2096. X        /* state of "newhi" changes */
  2097. X
  2098. X        if (first) {
  2099. X          movphy(px,py);
  2100. X          first = 0;
  2101. X          lstold = ptold;
  2102. X          if (init != 2) {
  2103. X            heap3[xx] = px;
  2104. X            heap3[xx+1] = py;
  2105. X            xx = xx + 2;
  2106. X          }
  2107. X          pthi = 0;
  2108. X          ochange = 0;
  2109. X        }
  2110. X        else if (change) {
  2111. X          /* Take care of special cases at end of arrays.  If init is 2 the */
  2112. X          /* endpoints are not connected to the old view. */
  2113. X          if (init==2 && ((!ptold && j==0)||(ptold && i==0))) {
  2114. X            movphy(px,py);
  2115. X            lstold = ptold;
  2116. X            pthi = 0;
  2117. X            ochange = 0;
  2118. X          }
  2119. X          else if (init==2 && ((!ptold && i>=m)||(ptold && j>=n))) {
  2120. X            movphy(px,py);
  2121. X            lstold = ptold;
  2122. X            pthi = 0;
  2123. X            ochange = 0;
  2124. X          }
  2125. X          /* If init is not 2 then we do want to connect the current line */
  2126. X          /* with the previous view at the endpoints.  */
  2127. X          /* Also find intersection point with old view. */
  2128. X          else  {
  2129. X            if (i == 0) {
  2130. X              sx1 = heap3[x];
  2131. X              sy1 = -1;
  2132. X              sx2 = heap3[x];
  2133. X              sy2 = heap3[y];
  2134. X            }
  2135. X            else if (i >= m) {
  2136. X              sx1 = heap3[x+m-1];
  2137. X              sy1 = heap3[y+m-1];
  2138. X              sx2 = heap3[x+m-1];
  2139. X              sy2 = -1;
  2140. X            }
  2141. X            else {
  2142. X              sx1 = heap3[x+i-1];
  2143. X              sy1 = heap3[y+i-1];
  2144. X              sx2 = heap3[x+i];
  2145. X              sy2 = heap3[y+i];
  2146. X            }
  2147. X
  2148. X            if (j == 0) {
  2149. X              su1 = u[0];
  2150. X              sv1 = -1;
  2151. X              su2 = u[0];
  2152. X              sv2 = v[0];
  2153. X            }
  2154. X            else if (j >= n) {
  2155. X              su1 = u[n-1];
  2156. X              sv1 = v[n-1];
  2157. X              su2 = u[n];
  2158. X              sv2 = -1;
  2159. X            }
  2160. X            else  {
  2161. X              su1 = u[j-1];
  2162. X              sv1 = v[j-1];
  2163. X              su2 = u[j];
  2164. X              sv2 = v[j];
  2165. X            }
  2166. X
  2167. X            /* Determine the intersection */
  2168. X            pl3cut(sx1,sy1,sx2,sy2,su1,sv1,su2,sv2,&cx,&cy);
  2169. X            if (cx == px && cy == py)  {
  2170. X              if (lstold && !ochange)
  2171. X                movphy(px,py);
  2172. X              else 
  2173. X                draphy(px,py); 
  2174. X
  2175. X              if (init != 2) {
  2176. X                heap3[xx] = px;
  2177. X                heap3[xx+1] = py;
  2178. X                xx = xx+2;
  2179. X              }
  2180. X              lstold = 1;
  2181. X              pthi = 0;
  2182. X            }
  2183. X            else {
  2184. X              if (lstold && !ochange)
  2185. X                 movphy(cx,cy);
  2186. X              else
  2187. X                 draphy(cx,cy);
  2188. X
  2189. X              lstold = 1;
  2190. X              if (init != 2) {
  2191. X                heap3[xx] = cx;
  2192. X                heap3[xx+1] = cy;
  2193. X                xx = xx+2;
  2194. X              }
  2195. X            }
  2196. X            ochange =1;
  2197. X          }
  2198. X        }
  2199. X
  2200. X        /* If point is high then draw plot to point and update view. */
  2201. X        if (pthi) {
  2202. X          if (lstold && ptold)
  2203. X            movphy(px,py);
  2204. X          else 
  2205. X            draphy(px,py); 
  2206. X
  2207. X          if (init != 2) {
  2208. X            heap3[xx] = px;
  2209. X            heap3[xx+1] = py;
  2210. X            xx = xx+2;
  2211. X          }
  2212. X          lstold = ptold;
  2213. X          ochange = 0;
  2214. X        }
  2215. X
  2216. X        pnewhi = newhi;
  2217. X
  2218. X        if (ptold)
  2219. X          i = i+1;
  2220. X        else
  2221. X          j = j+1;
  2222. X
  2223. X        if (xx>=x) fatal("Heap overflow in plnxtv.");
  2224. X      }
  2225. X
  2226. X      /* Transfer the peak points to the RHS of the heap */
  2227. X
  2228. X      if(init != 2) {
  2229. X        m = xx/2;
  2230. X        xx = 0;
  2231. X        y = heaps - m;
  2232. X        x = y - m;
  2233. X        for(i=0; i<m; i++) {
  2234. X          heap3[x+i] = heap3[xx];
  2235. X          heap3[y+i] = heap3[xx+1];
  2236. X          xx = xx+2;
  2237. X        }
  2238. X      }
  2239. X}
  2240. X
  2241. SHAR_EOF
  2242. echo "End of archive 6 (of 7)"
  2243. # if you want to concatenate archives, remove anything after this line
  2244. exit
  2245.